/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "UI.h"
#include <UI/布局.h>
#include "ui绘制模板.h"

#include "UI/intern/ui列表.h"

static float32 g_部件小距离偏移 = 1;




void f_ui_draw_temple_树形框(C_Widget* self, S_2DConvexRect& 区域, S_2D颜色包& 颜色) {
	C_树形框& box = *static_cast<C_树形框*>(self);
	
	区域.offset = { box.m_行高度 * self->m_UIctx->m_DPI, self->m_Pos.y + self->m_父部件->m_GlobalLoc.y };
	区域.size = self->m_父部件->m_Size;
	区域.AA_type = {1, 0};

	颜色.m_颜色 = box.m_颜色A;
	颜色.m_模式 = DEF_2DShaderType_Stripe;
}

int32 f_ui_drawTemple_刻度缩放(float32& 刻度跨度, float32 缩放, float32 初始跨度) {
	float32 缩放跨度 = 初始跨度 * 缩放;
	
	float32 刻度数值跨度 = 1 / 缩放;
	int32 缩放比 = max(刻度数值跨度, 1);
	缩放比 = pow(2, int32(log2(缩放比)));

	刻度跨度 = 缩放跨度 * 缩放比;

	uint32 num1;
	int32 刻度数字跨度 = 缩放比 <= 1 ? 1 : 缩放比*5;
	if (缩放 > 1) {
		缩放比 = pow(2, int32(log2(缩放)));
		刻度数字跨度 = max(5 / 缩放比, 1);

		if(缩放比 == 1) {
			刻度跨度 = 缩放跨度;
		}
		else if(缩放比 == 2) {
			刻度跨度 = 缩放跨度 * 2 / 5;
		}
		else {
			刻度跨度 = 缩放跨度 * 2 / 10;
		}
	}
	else {
		刻度数字跨度 = 缩放比*5;
	}

	return 刻度数字跨度;
}

void f_ui_draw_temple_拖放条手柄(
	C_Widget* self, 
	std::vector<S_2DConvexRect>&	区域, 
	std::vector<S_GPU内存块*>&		形状, 
	std::vector<S_2D颜色包>&		颜色, 
	std::vector<vec2>&				位置,
	bool							扩展
) {
	float32 dpi = self->m_UIctx->m_DPI;

	vec2 pos = self->m_Pos;
	S_2DConvexRect rect{};
	rect.size = self->m_Size;
	
	rect.radius.x = min(rect.size.x, rect.size.y);
	rect.radius.y = rect.radius.x;

	形状.push_back(&(self->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
	区域.push_back(rect);
	颜色.push_back(self->m_ColorA);
	位置.push_back(pos);

	auto color = self->m_ColorA;
	float32 gap = min(rect.size.x, rect.size.y);

	//纵向
	if (rect.size.y > rect.size.x) {
		if (扩展) {
			rect.size.y *= 0.9;
		}
		else {
			rect.size.y = min(50 * dpi, rect.size.y);
		}
	}
	//横向
	else {
		if (扩展) {
			rect.size.x *= 0.9;
		}
		else {
			rect.size.x = min(50 * dpi, rect.size.x);
		}
	}

	if (扩展) {
		rect.size -= gap * 0.3;
		pos += (self->m_Size - rect.size) * 0.5;
		color.m_颜色 += 40;
	}
	else {
		rect.size -= gap * 0.6;
		pos += (self->m_Size - rect.size) * 0.5;
		color.m_颜色 += 20;
	}
	rect.radius = min(rect.radius, _Vec2(min(rect.size.x, rect.size.y) * 0.5));
	
	形状.push_back(&(self->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
	区域.push_back(rect);
	颜色.push_back(color);
	位置.push_back(pos);

}

void f_ui_drawTemple_PropsName(S_矢量绘制数据& 绘制数据, S_Props& prop, vec2 pos, vec2 size) {
	if(prop.m_Name.empty()) return;

	绘制数据.字符文本.emplace_back(prop.m_Name);
	绘制数据.字符区域.emplace_back(S_Rect2Df{pos, size});
	绘制数据.字符颜色.emplace_back(S_UI主题::uic_文字颜色);
	绘制数据.对齐方式.emplace_back(E_对齐方式::e_据中对齐);
}

void f_ui_drawTemple_PropsOps(
	S_矢量绘制数据&	绘制数据,

	C_Widget*		widget,
	S_Props&		prop,
	S_2DConvexRect& rect,
	vec2			pos

	) {
	
	绘制数据.位置.emplace_back(pos);
	绘制数据.区域.emplace_back(rect);
	绘制数据.颜色.emplace_back(widget->m_ColorA);

	if (prop.m_风格属性->m_图元形状) {
		绘制数据.形状.emplace_back(prop.m_风格属性->m_图元形状);

		vec2 icoSize = rect.size;

		绘制数据.图标名称.emplace_back(prop.m_风格属性->m_ICO); 
		绘制数据.图标颜色.emplace_back(S_UI主题::uic_图标颜色);
		绘制数据.图标位置.emplace_back(pos + icoSize * 0.5f);
		绘制数据.图标大小.emplace_back(icoSize * 0.75);
	}
	else {
		绘制数据.形状.emplace_back(&(widget->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
	}

	if (widget->m_自定义属性.m_布局方式 != E_布局方式::e_等比) {
		绘制数据.字符文本.emplace_back(widget->m_WName);
		绘制数据.字符区域.emplace_back(S_Rect2Df{widget->m_Pos, rect.size});
		绘制数据.字符颜色.emplace_back(S_UI主题::uic_文字颜色);
		绘制数据.对齐方式.emplace_back(E_对齐方式::e_据中对齐);
	}

}

void f_ui_drawTemple_PropsLineStr(
	S_矢量绘制数据& 绘制数据,

	C_Widget* widget,
	S_Props& prop,
	S_2DConvexRect& rect,
	vec2			pos
) {
	绘制数据.位置.emplace_back(pos);
	绘制数据.区域.emplace_back(rect);
	绘制数据.颜色.emplace_back(widget->m_ColorA);

	const auto& str = f_prop_LineStr(prop);

	vec2 size = rect.size;
	size.x *= 0.3;

	绘制数据.字符文本.emplace_back(prop.m_Name);
	绘制数据.字符区域.emplace_back(S_Rect2Df{widget->m_Pos, size});
	绘制数据.字符颜色.emplace_back(S_UI主题::uic_文字颜色);

	if (str.size()) {
		绘制数据.字符文本.emplace_back(str);
		绘制数据.字符区域.emplace_back(S_Rect2Df{widget->m_Pos + vec2{size.x, 0}, rect.size - vec2{size.x, 0}});
		绘制数据.字符颜色.emplace_back(S_UI主题::uic_文字颜色);
	}
	
}

void f_ui_drawTemple_PropsValue(
	S_矢量绘制数据& 绘制数据, 
	C_Widget* widget, S_Props& prop, S_2DConvexRect& rect, vec2 pos)
{
	绘制数据.位置.emplace_back(pos);
	绘制数据.区域.emplace_back(rect);
	绘制数据.形状.emplace_back(&(widget->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
	绘制数据.颜色.emplace_back(widget->m_ColorA);
	
	绘制数据.字符文本.emplace_back(f_ui_get编辑框文本(widget));
	绘制数据.字符区域.emplace_back(S_Rect2Df{widget->m_Pos, rect.size});
	绘制数据.字符颜色.emplace_back(S_UI主题::uic_文字颜色);
	绘制数据.对齐方式.emplace_back(E_对齐方式::e_据中对齐);
}

void f_ui_drawTemple_PropsVec(
	S_矢量绘制数据&	绘制数据, C_Widget* widget, S_Props& prop, S_2DConvexRect& rect, vec2 pos)
{
	auto se = widget->f_get更新组件();

	for (uint32 k = 0; k < se.m_Num; ++k) {
		rect.offset = {};
		rect.size = se.m_W[k]->m_Size;
		绘制数据.位置.emplace_back(pos + se.m_W[k]->m_Pos);
		绘制数据.区域.emplace_back(rect);
		绘制数据.形状.emplace_back(se.m_W[k]->m_图元形状);
		绘制数据.颜色.emplace_back(se.m_W[k]->m_ColorA);

		绘制数据.字符文本.emplace_back(f_ui_get编辑框文本(se.m_W[k]));
		绘制数据.字符区域.emplace_back(S_Rect2Df{绘制数据.位置.back(), rect.size});
		绘制数据.字符颜色.emplace_back(S_UI主题::uic_文字颜色);
		绘制数据.对齐方式.emplace_back(E_对齐方式::e_据中对齐);
	}
}

void f_ui_drawTemple_PropsUI32Flage(
	S_矢量绘制数据& 绘制数据, 
	C_Widget* widget, S_Props& prop, S_2DConvexRect& rect, vec2 pos)
{
	auto se = widget->f_get更新组件();

	const S_Prop枚举项& item = f_prop_位域枚举项(widget->m_自定义属性);
	const uint32 flage = f_prop_UI32位域枚举(widget->m_自定义属性);

	for (uint32 k = 0; k < se.m_Num; ++k) {
		vec2 pos2 = pos + se.m_W[k]->m_Pos;
		vec2 size = se.m_W[k]->m_Size;

		rect.offset = {};
		rect.size = size;

		绘制数据.位置.emplace_back(pos2);
		绘制数据.区域.emplace_back(rect);
		绘制数据.形状.emplace_back(se.m_W[k]->m_图元形状);
		绘制数据.颜色.emplace_back((flage&1<<k) ? S_UI主题::uic_焦点色 : se.m_W[k]->m_ColorA);

		if (item.m_数量) {
			vec2 icoSize = vec2{size.y, size.y};

			绘制数据.图标名称.emplace_back(item.m_ICO[k]); 
			绘制数据.图标颜色.emplace_back(S_UI主题::uic_图标颜色);
			绘制数据.图标位置.emplace_back(pos2 + icoSize * 0.5f);
			绘制数据.图标大小.emplace_back(icoSize * 0.75);
		}
	}
}

void f_ui_drawTemple_PropsEnum(
	S_矢量绘制数据& 绘制数据, 
	C_Widget* widget, S_Props& prop, S_2DConvexRect& rect, vec2 pos)
{
	auto se = widget->f_get更新组件();

	const auto& select = f_prop_enum(widget->m_自定义属性);
	const auto& item = f_prop_enumItem(widget->m_自定义属性);
	uint32 元素个数 = widget->m_自定义属性.m_值元素个数;

	for (uint32 k = 0; k < se.m_Num; ++k) {
		vec2 pos2 = pos + se.m_W[k]->m_Pos;
		vec2 size = se.m_W[k]->m_Size;

		rect.offset = {};
		rect.size = size;

		绘制数据.位置.emplace_back(pos2);
		绘制数据.区域.emplace_back(rect);
		绘制数据.形状.emplace_back(se.m_W[k]->m_图元形状);
		绘制数据.颜色.emplace_back(k == select ? S_UI主题::uic_焦点色 : se.m_W[k]->m_ColorA);

		if (元素个数) {
			vec2 icoSize = vec2{size.y, size.y};
			绘制数据.图标名称.emplace_back(item.m_ICO[k]); 
			绘制数据.图标颜色.emplace_back(S_UI主题::uic_图标颜色);
			绘制数据.图标位置.emplace_back(pos2 + icoSize * 0.5f);
			绘制数据.图标大小.emplace_back(icoSize * 0.75);
		}
	}
}

void f_ui_drawTemple_Strings(S_矢量绘制数据& 绘制数据, vec2 pos, vec2 size, S_RGBA8UI color, bool 自动换行) {
	for (auto& e : 绘制数据.字符文本) {
		绘制数据.字符颜色.push_back(color);
		绘制数据.字符区域.push_back({pos, size});
		绘制数据.对齐方式.push_back(E_对齐方式::e_左对齐);
		pos.y += size.y;
	}
}

void f_ui_drawTemple_ColorDisc(S_矢量绘制数据& 绘制数据, C_Widget* self, vec2 pos, vec2 size) {
	S_2DConvexRect rect{};

	rect.radius = _Vec2(self->m_UIctx->m_DPI * 3);

	绘制数据.形状.push_back(&(self->m_UIctx->m_Ctx.m_几何图形->m_平面圆角矩形));
	绘制数据.区域.push_back(rect);
	绘制数据.颜色.push_back(self->m_ColorA);
	绘制数据.位置.push_back(pos);

	绘制数据.形状.push_back(&(self->m_UIctx->m_Ctx.m_几何图形->m_平面圆形));
	绘制数据.区域.push_back(rect);
	绘制数据.颜色.push_back(self->m_ColorA);
	绘制数据.位置.push_back(pos);


}

void f_ui_drawTemple_PropsObjectContainer(S_矢量绘制数据& 绘制数据, C_Widget* widget, const S_Props& prop) {
	S_2DConvexRect rect{};
	vec2 pos = widget->m_Pos;

	rect.radius = _Vec2(widget->m_UIctx->m_DPI * 3);
	rect.size = widget->m_子组件[0]->m_Size;
	rect.AA_type = {1, 0};

	for (uint32 i = 0; i < 3; ++i) {
		rect.size = widget->m_子组件[i]->m_Size;
		绘制数据.位置.emplace_back(widget->m_子组件[i]->m_Pos + pos);
		绘制数据.区域.emplace_back(rect);
		绘制数据.形状.emplace_back(widget->m_子组件[i]->m_图元形状);
		绘制数据.颜色.push_back(widget->m_子组件[i]->m_ColorA);
	}
	

	float32 icoSize = widget->m_子组件[2]->m_Size.y;
	绘制数据.图标位置.emplace_back(pos + widget->m_子组件[0]->m_Pos + icoSize*0.5f);
	绘制数据.图标大小.emplace_back(_Vec2(icoSize*0.65));
	绘制数据.图标名称.emplace_back(widget->m_子组件[0]->m_ICO);
	绘制数据.图标颜色.emplace_back(S_UI主题::uic_图标颜色);

	绘制数据.图标位置.emplace_back(pos + widget->m_子组件[2]->m_Pos + icoSize*0.5f);
	绘制数据.图标大小.emplace_back(_Vec2(icoSize*0.65));
	绘制数据.图标名称.emplace_back(widget->m_子组件[2]->m_ICO);
	绘制数据.图标颜色.emplace_back(S_UI主题::uic_图标颜色);

	const auto* ob = f_prop_Object(prop);
	绘制数据.字符颜色.push_back(S_UI主题::uic_文字颜色);
	绘制数据.字符区域.push_back({pos + widget->m_子组件[1]->m_Pos, widget->m_子组件[1]->m_Size});
	绘制数据.对齐方式.push_back(E_对齐方式::e_左对齐);
	绘制数据.字符文本.push_back(ob ? ob->m_Name : u"none");
	
}





ui_绘制模板_Vec::ui_绘制模板_Vec() {

}

void ui_绘制模板_Vec::f_Layout(C_Widget* w) {
	auto e = w->mf_get更新组件(w);

	float32 h = w->m_Size.y / e.m_Num;

	vec2 pos = { 0, 0 };
	vec2 size = { w->m_Size.x , h };

	for (uint8 i = 0; i < e.m_Num; ++i) {
		pos.y = h * i;
		e.m_W[i]->f_setPos(pos);
		e.m_W[i]->f_setSize(size);
	}
}





ui_绘制模板_行文本绘制::ui_绘制模板_行文本绘制(uint16 单行字符最大数量) : m_字体(nullptr) {
	m_画布 = nullptr;
	m_文本.id_变换 = {};
	m_文本.id_文本 = {};
	m_文本.id_颜色 = {};
}
ui_绘制模板_行文本绘制::~ui_绘制模板_行文本绘制() {
	if(m_文本.id_变换.m_Buf) f_bm_erase(m_文本.id_变换);
	if(m_文本.id_文本.m_Buf) f_bm_erase(m_文本.id_文本);
	if(m_文本.id_颜色.m_Buf) f_bm_erase(m_文本.id_颜色);
}

void ui_绘制模板_行文本绘制::f_Draw(S_2D画布* 画布, const S_Font* 字体, uint16 属性ID) {
	m_画布 = 画布;
	auto& 层 = m_画布->m_surf[m_文本.层ID];
	层.m_顶点数量 = 1;
}

void ui_绘制模板_行文本绘制::f_alloc(uint32 变换num, uint32 所有字符num) {
	//return;
	m_单行字符最大数量 = 所有字符num;
	//assert(变换num);
	if(!变换num) {
		m_画布->m_surf[m_文本.层ID].m_实例数量 = 变换num;
		m_画布->m_surf[m_文本.层ID].m_实例偏移 = m_文本.id_变换.m_Mem.m_偏移;
		return;
	}

	f_bm_resize(m_文本.id_变换, 变换num);
	f_bm_resize(m_文本.id_颜色, 变换num);
	f_bm_resize(m_文本.id_文本, 变换num * m_单行字符最大数量);

	f_vg_set实例数量(m_画布, m_文本.层ID, 变换num);

	m_Prt.coord = f_buf_Mat3X2_ptr(m_文本.id_变换);
	m_Prt.color = f_buf_UI32_ptr(m_文本.id_颜色);
	m_Prt.text = f_buf_I32_ptr(m_文本.id_文本);
	
	m_画布->m_surf[m_文本.层ID].m_实例数量 = 变换num;
	m_画布->m_surf[m_文本.层ID].m_实例偏移 = m_文本.id_变换.m_Mem.m_偏移;

	return;
}

void ui_绘制模板_行文本绘制::f_设置文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt) {
	txt = txt.substr(0, DEF_Min(txt.size(), m_单行字符最大数量));

	txt = f_vg_set行文本(m_画布, m_文本.层ID, txt, 变换GPU偏移 * m_单行字符最大数量, rect.extent.x, m_Prt.text);
	assert(txt.size() <= m_单行字符最大数量);
	m_Prt.coord[变换GPU偏移].row0 = rect.offset;
	m_Prt.coord[变换GPU偏移].row1.x = 0;
	m_Prt.coord[变换GPU偏移].row1.y = txt.size();
	m_Prt.coord[变换GPU偏移].row2.x = 变换GPU偏移 * m_单行字符最大数量 + m_文本.id_文本.m_Mem.m_偏移;

	m_Prt.color[变换GPU偏移] = f_PackData4X8(color);
}

void ui_绘制模板_行文本绘制::f_居中绘制文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::u16string txt) {
	txt = txt.substr(0, DEF_Min(txt.size(), m_单行字符最大数量));
	float32 文本宽度 = rect.extent.x * 1.01;
}

void ui_绘制模板_行文本绘制::f_绘制文本(const S_Rect2Df& rect, const S_RGBA8UI& color, uint32 变换GPU偏移, std::wstring txt, E_对齐方式 方式, float32 缩放) {
	txt = txt.substr(0, DEF_Min(txt.size(), m_单行字符最大数量));

	float32 w = 缩放;
	switch (方式) {
		case E_对齐方式::e_纵向齐:
			w *= rect.extent.y;
			break;
		default:
			w *= rect.extent.x;
			break;
	}
}


void ui_绘制模板_行文本绘制::f_绘制刻度数字(S_Rect2Df & rect, uint32 num, vec2 开始_步进, float32 间隔) {
	for (uint32 i = 0; i < num; ++i) {
		auto txt = f_整数值转宽字符串64(开始_步进.x);
	}
}

void ui_绘制模板_行文本绘制::f_Close(S_2D画布* 画布) {
	f_vg_set实例数量(画布, m_文本.层ID, 0);
}

void ui_绘制模板_行文本绘制::f_Close(uint32 num) {
	if(m_画布) f_vg_set实例数量(m_画布, m_文本.层ID, num);
}





ui_绘制模板_预设图形::ui_绘制模板_预设图形() {
	m_属性 = 0;
	m_图元 = {};
	m_画布 = nullptr;
}

ui_绘制模板_预设图形::~ui_绘制模板_预设图形() {
	//if(!m_图元.链接属性);
	if(!m_图元.链接变换 && m_图元.变换) f_bm_erase(*m_图元.变换);
	if(!m_图元.链接颜色 && m_图元.颜色) f_bm_erase(*m_图元.颜色);
	if(!m_图元.链接线属性 && m_图元.线属性) f_bm_erase(*m_图元.线属性);
	if(!m_图元.链接纹理属性 && m_图元.纹理属性) f_bm_erase(*m_图元.纹理属性);
}

void ui_绘制模板_预设图形::f_Draw(S_2D画布* 画布, const S_凸边图元& 链接参数, E_笔刷类型 笔刷, float32 线宽) {
	m_画布 = 画布;
	
	E_填充模式 填充模式;
	switch (笔刷) {
	case E_笔刷类型::e_单色填充:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填充面;
		goto To_绘制单色面线;
	case E_笔刷类型::e_单色描边:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填充线;
		goto To_绘制单色面线;
	case E_笔刷类型::e_单色边面:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填边面;
		goto To_绘制单色边面;
	case E_笔刷类型::e_条纹:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		//m_图元 = f_vg_gen凸边纹理图元(m_画布, 链接参数);
		填充模式 = E_填充模式::e_填充面;
		goto To_绘制纹理面线;
	case E_笔刷类型::e_单色纹理:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		//m_图元 = f_vg_gen凸边纹理图元(m_画布, 链接参数);
		goto To_绘制纹理面线;

	case E_笔刷类型::e_纹理:
		//m_图元 = f_vg_gen纹理图元(m_画布, 链接参数);
		//f_vg_画纹理(m_画布, m_图元, nullptr);
		return;
	case E_笔刷类型::e_多纹理:
		//m_图元 = f_vg_gen纹理图元(m_画布, 链接参数);
		//f_vg_画纹理(m_画布, m_图元, nullptr);
		return;

	case E_笔刷类型::e_渐变:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		f_vg_画渐变(m_画布, m_图元);
		return;

	case e_色轮:
		m_图元 = f_vg_gen凸边图元(m_画布, 链接参数);
		f_vg_画色轮(m_画布, m_图元);
		return;
		
	case E_笔刷类型::e_噪波:
		//m_图元 = f_vg_gen纹理图元(m_画布, 链接参数);
		//m_层ID = f_vg_画噪波(m_画布, m_图元);
		return;
	}

To_绘制单色面线:
	f_vg_画间接凸边形(m_画布, m_图元, 填充模式);
	return;

To_绘制纹理面线:
	//f_vg_画条纹纹理(m_画布, m_图元, 填充模式);
	return;

To_绘制单色边面:
	return;

}

void ui_绘制模板_预设图形::f_alloc(uint32 num) {
	
	auto& 层 = m_画布->m_surf[m_图元.层];

	层.m_顶点数量 = 层.m_顶点.m_Mem.m_数量;
	层.m_顶点偏移 = 层.m_顶点.m_Mem.m_偏移;

	层.m_实例数量 = num;
	层.m_实例偏移 = m_图元.变换->m_Mem.m_偏移;
}


void ui_绘制模板_预设图形::f_setColor(uint32 id, const S_RGBA8UI& C) {
	if(!m_画布) return;
	
	if (id >= m_图元.颜色->m_Mem.m_数量) {
		std::cout<<"画预设图形::f_setColor = "<<id<<" :"<< m_图元.颜色->m_Mem.m_数量<<std::endl;
		return;
	}

	assert(id < m_图元.颜色->m_Mem.m_数量);
	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8(C);
	//m_间接Ptr.p颜色[id] = f_PackData4X8(C);
	//std::cout<<"m_间接Ptr.p颜色 = " << m_间接Ptr.p颜色 << " : " << m_图元.颜色->m_Mem.m_大小 <<" : " << id << std::endl;
}

void ui_绘制模板_预设图形::f_绘制滚动条(uint32 id, C_Widget* 滚动条) {
	assert(id < m_图元.变换->m_Mem.m_数量);
	assert(id < m_图元.颜色->m_Mem.m_数量);
	assert(id < m_图元.线属性->m_Mem.m_数量);

	mat3X2 mat;
	mat.row0 = 滚动条->m_Pos;
	mat.row1 = 滚动条->m_Size;
	mat.row2 = { 3, 0 };

	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8(滚动条->m_颜色A);
	
	auto& 区间 = m_画布->m_surf[m_图元.层].m_间接;
	f_buf_Indirect_at(区间, id) = { S_Widget预设凸包图元::m_圆角矩形.y - S_Widget预设凸包图元::m_圆角矩形.x, 1, S_Widget预设凸包图元::m_圆角矩形.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };

}

uint32 ui_绘制模板_预设图形::f_fill顶点(vec2* 顶点, uint32 num) {
	auto& 层 = m_画布->m_surf[m_图元.层];
	f_bm_resize(层.m_顶点, num);
	
	for (uint32 i = 0; i < num; ++i) {
		f_buf_图元顶点_at(层.m_顶点, i) = {顶点[i], {1,1}, {1,1}};
		assert(i < 层.m_顶点.m_Mem.m_数量);
	}
	
	m_画布->m_surf[m_图元.层].m_顶点数量 = num;
	m_画布->m_surf[m_图元.层].m_顶点偏移 = m_画布->m_surf[m_图元.层].m_顶点.m_Mem.m_偏移;
	return m_画布->m_surf[m_图元.层].m_顶点偏移;
}

void ui_绘制模板_预设图形::f_set单色填充(uint32 id, const mat3X2& mat, const S_RGBA8UI& C, const uvec2& 图元ID, float32 线宽) {
	auto& 层 = m_画布->m_surf[m_图元.层];

	assert(id < m_图元.变换->m_Mem.m_数量);
	assert(id < m_图元.颜色->m_Mem.m_数量);
	assert(id < m_图元.线属性->m_Mem.m_数量);

	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8(C);
	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	
	auto& 区间 = m_画布->m_surf[m_图元.层].m_间接;
	f_buf_Indirect_at(区间, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };

	层.m_线宽 = 线宽;
}

void ui_绘制模板_预设图形::f_set单色线(uint32 id, const mat3X2& mat, const S_LineProp& C, const uvec2& 图元ID, float32 线宽) {
	auto& 层 = m_画布->m_surf[m_图元.层];

	assert(id < m_图元.变换->m_Mem.m_数量);
	assert(id < m_图元.颜色->m_Mem.m_数量);
	assert(id < m_图元.线属性->m_Mem.m_数量);

	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	f_buf_UI32_at(*m_图元.颜色, id) = f_PackData4X8({ 255,255,0,255 });
	f_buf_线属性_at(*m_图元.线属性, id) = C;
	f_buf_Indirect_at(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
	
	层.m_线宽 = 线宽;
}

void ui_绘制模板_预设图形::f_set色轮(uint32 id, const mat3X2& mat, const uvec2& 图元ID, const S_ColorTake& ct) {
	auto& 层 = m_画布->m_surf[m_图元.层];

	f_buf_Mat3X2_at(*m_图元.变换, id) = mat;
	f_buf_Indirect_at(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_图元.变换->m_Mem.m_偏移) };
}

void ui_绘制模板_预设图形::f_Close(uint32 num) {
	if(!m_画布) return;

	f_vg_set实例数量(m_画布, m_图元.层, num);
	
	auto& 区间 = m_画布->m_surf[m_图元.层].m_间接;
	for (uint32 i = num; i < 区间.m_Mem.m_数量; ++i) {
		f_buf_Indirect_ptr(区间)[i] = {};
	}
}





ui_绘制模板_图标::ui_绘制模板_图标() {
	m_ID = {};
	m_Prt = {};
}

ui_绘制模板_图标::~ui_绘制模板_图标() {
	if(m_ID.id_变换.m_Buf) f_bm_erase(m_ID.id_变换);
	if(m_ID.id_颜色.m_Buf) f_bm_erase(m_ID.id_颜色);
}

void ui_绘制模板_图标::f_Draw单色(S_2D画布* 画布, uint16 属性ID, std::string ico集) {
	m_画布 = 画布;
}

void ui_绘制模板_图标::f_Draw彩色(S_2D画布* 画布, uint16 属性ID, std::string ico集) {
	m_画布 = 画布;
	//f_ui绘制模板_图标绘制(m_画布, m_ID, 属性ID, ico集);
}

void ui_绘制模板_图标::f_alloc(uint32 num) {
	f_bm_resize(m_ID.id_变换, num);
	f_bm_resize(m_ID.id_颜色, num);

	auto& 层 = m_画布->m_surf[m_ID.层ID];
	层.m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	层.m_实例数量 = m_ID.id_变换.m_Mem.m_数量;
	层.m_顶点偏移 = 层.m_顶点.m_Mem.m_偏移;
	层.m_顶点数量 = 1;

	if (num) {
		m_Prt.pCoord = f_buf_Mat3X2_ptr(m_ID.id_变换);
		m_Prt.pColor = f_buf_UI32_ptr(m_ID.id_颜色);
	}
	else {
		m_Prt = {};
	}
}

void ui_绘制模板_图标::f_set(std::string ico, uint32 offset, const mat3X2 mat, const S_RGBA8UI 颜色) {
	assert(offset < m_ID.id_变换.m_Mem.m_数量);
	assert(offset < m_ID.id_颜色.m_Mem.m_数量);
	m_Prt.pCoord[offset] = mat;
	m_Prt.pCoord[offset].row2.x = f_vg_get图标坐标(m_画布, m_ID.层ID, ico);
	m_Prt.pColor[offset] = f_PackData4X8(颜色);
}

void ui_绘制模板_图标::f_Close() {
	f_vg_set实例数量(m_画布, m_ID.层ID, 0);
}



ui_绘制模板_刻度线::ui_绘制模板_刻度线() {
	m_Mat = nullptr;
	m_线Color = nullptr;

	m_间隔比例 = { 20,20 };
	m_ID = {};
}

ui_绘制模板_刻度线::~ui_绘制模板_刻度线() {
	if(m_ID.id_变换.m_Buf) f_bm_erase(m_ID.id_变换);
	if(m_ID.id_颜色.m_Buf) f_bm_erase(m_ID.id_颜色);
}

void ui_绘制模板_刻度线::f_Draw(S_2D画布* 画布, uint16 属性ID) {
	m_画布 = 画布;
	m_ID.id_变换 = f_bm_alloc(S_2D画布::g图标变换, 1);
	m_ID.id_颜色 = f_bm_alloc(S_2D画布::g图标颜色, 1);
	m_ID.层ID = f_vg_gen刻度线(画布, 属性ID, 1.0);
}

void ui_绘制模板_刻度线::f_Draw网格(S_2D画布* 画布, uint16 属性ID) {
	m_画布 = 画布;

	m_ID.id_变换 = f_bm_alloc(S_2D画布::g图标变换, 1);
	m_ID.id_颜色 = f_bm_alloc(S_2D画布::g图标颜色, 1);
	
	m_ID.层ID = f_vg_画网格刻度线(画布, 属性ID, 1.0);
}

void ui_绘制模板_刻度线::f_alloc(uint32 num) {
	f_vg_set实例数量(m_画布, m_ID.层ID, num);
	if (!num) return;
	
	m_Mat = f_buf_Mat3X2_ptr(m_ID.id_变换);
	m_线Color = f_buf_UI32_ptr(m_ID.id_颜色);

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_数量;

	m_画布->m_surf[m_ID.层ID].m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = m_ID.id_变换.m_Mem.m_数量;
}

void ui_绘制模板_刻度线::f_set(uint32 线num, const mat3X2 mat, S_RGBA8UI 颜色, uint32 offset) {
	f_vg_set顶点数量(m_画布, m_ID.层ID, 线num);
	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = m_ID.id_变换.m_Mem.m_数量;
	m_Mat[offset] = mat;
	m_线Color[offset] = f_PackData4X8(颜色);
}

void ui_绘制模板_刻度线::f_set(uint32 offset, uint32 线num, const mat3X2 mat, S_RGBA8UI 颜色) {
	f_vg_set顶点数量(m_画布, m_ID.层ID, 线num);
	m_Mat[offset] = mat;
	m_线Color[offset] = f_PackData4X8(颜色);
}





//ui_绘制模板_块文本绘制::ui_绘制模板_块文本绘制() {
//}
//
//S_sf_文字GPU参数映射 ui_绘制模板_块文本绘制::f_GPU参数修改_begin(S_2D画布* 画布, uint32 num, uint32 行) {
//	bool GPU参数重新配置 = false;
//
//	GPU参数重新配置 |= f_vg_resize参数实例(画布, m_文本.id_变换, num);
//	GPU参数重新配置 |= f_vg_resize参数实例(画布, m_文本.id_颜色, num);
//
//	f_vg_set实例数量(画布, m_文本.id_元素, num);
//	f_vg_set实例数量(画布, m_行号.id_元素, 行*5);
//
//	m_映射指针.GPU参数重置 = GPU参数重新配置;
//
//	return m_映射指针;
//}
//
//void ui_绘制模板_块文本绘制::f_填充文本(S_2D画布* 画布, std::wstring txt, const S_RGBA8UI& color, vec2 pos, uint32 offset)
//{
//	//f_vg_set文本段(画布, m_文本对象, txt, offset);
//
//	auto& 字体 = 画布->m_调色板->m_Fonts[画布->m_surf[m_文本.id_元素].m_纹理];
//	for (auto e : txt) {
//		m_映射指针.coord[offset].row0 = pos;
//		m_映射指针.coord[offset].row1 = { 1,1 };
//		//m_映射指针.coord[offset].row2.x = 字体.f_从外部编码取内部编码(e);
//		m_映射指针.coord[offset].row2.x = e;
//		m_映射指针.coord[offset].row2.y = 0;
//
//		m_映射指针.color[offset] = f_PackData4X8(color);
//
//		pos.x += 字体.f_get字符宽度(e) + S_UI主题::ui_文字间隔;
//		++offset;
//	}
//	//f_vg_set单色(画布, m_文本.id_颜色, offset, color);
//
//	f_vg_set实例数量(画布, m_文本.id_元素, txt.size());
//}
//
//void ui_绘制模板_块文本绘制::f_填充文本(S_2D画布* 画布, const S_文档文本& txt, vec2 pos, const S_Font& 字体, int16 行距) {
//	uint32 offset = 0;
//	vec2 左边顶边 = pos;
//	左边顶边.y += 0.5 * 行距;
//	//
//	uint32 行数量 = txt.m_文本块.size();
//	for (uint32 y = 0; y < 行数量; ++y) {
//		//uint32 num = txt.m_文本块[y].size();
//		//
//		//auto* t = txt.m_文本块[y].data();
//		//auto* c = txt.m_Color[y].data();
//		////float32 左边 = 0;
//		//for (uint32 i = 0; i < num; ++i) {
//		//	uint32 id = offset + i;
//		//	m_映射指针.coord[id].row0 = 左边顶边;
//		//	m_映射指针.coord[id].row1 = { 1,1 };
//		//	//m_映射指针.coord[id].row2.x = 字体.f_从外部编码取内部编码(t[i]);
//		//	m_映射指针.coord[id].row2.x = t[i];
//		//	m_映射指针.coord[id].row2.y = 0;
//		//
//		//
//		//	m_映射指针.color[id] = f_PackData4X8(c[i]);
//		//
//		//
//		//	if (t[i] == '\t') {
//		//		左边顶边.x += 字体.m_字号*2 + S_UI主题::ui_文字间隔;
//		//	}
//		//	else {
//		//		左边顶边.x += 字体.f_get字符宽度(t[i]) + S_UI主题::ui_文字间隔;
//		//	}
//		//
//		//}
//
//
//		//uint32 行号GPU偏移 = y * 5;
//		//auto 行号文本 = f_整数值转宽字符串(y);
//		//uint8 行号文本数量 = 行号文本.size();
//		//float32 行号左边 = 0;
//		//for (uint8 i = 0; i < 行号文本数量; ++i) {
//		//	m_行号映射指针.coord[行号GPU偏移].row0 = { 行号左边, 左边顶边.y };
//		//	m_行号映射指针.coord[行号GPU偏移].row1 = { 1,1 };
//		//	//m_行号映射指针.coord[行号GPU偏移].row2.x = 字体.f_从外部编码取内部编码(行号文本[i]);
//		//	m_行号映射指针.coord[行号GPU偏移].row2.x = 行号文本[i];
//		//	m_行号映射指针.coord[行号GPU偏移].row2.y = 0;
//		//	m_行号映射指针.color[行号GPU偏移] = f_PackData4X8(S_UI主题::uic_编辑框行号);
//		//
//		//	行号左边 += 字体.f_get字符宽度(行号文本[i]) + S_UI主题::ui_文字间隔;
//		//	++行号GPU偏移;
//		//}
//		//
//		//
//		//offset += num;
//		//左边顶边.x = pos.x;
//		//左边顶边.y += 字体.m_字号 + 行距;
//	}
//	//for (uint32 y = 0; y < 行数量; ++y) {
//	//	offset += txt.m_文本块[y].size();
//	//}
//	f_vg_set实例数量(画布, m_文本.id_元素, offset);
//}
//
//void ui_绘制模板_块文本绘制::f_GPU参数修改_end(S_2D画布* 画布)
//{
//	f_vg_unmapGPU参数(画布, m_文本.id_变换);
//	f_vg_unmapGPU参数(画布, m_文本.id_颜色);
//
//	f_ui绘制模板_unmap参数指针(画布, m_行号);
//
//	m_映射指针 = { nullptr, nullptr };
//	m_行号映射指针 = {};
//}
//
//void ui_绘制模板_块文本绘制::f_开启编辑(S_2D画布* 画布, C_Widget* w) {
//	
//
//}
//
//void ui_绘制模板_块文本绘制::f_输入(S_2D画布* 画布, C_文本框* box, std::wstring& text) {
//	mat3X2 editBoxMat;
//
//	editBoxMat.row0 = box->g光标绘制位置;
//	editBoxMat.row1 = {1, 20};
//	editBoxMat.row2 = { 1, 0 };
//	f_vg_set变换(画布, m_光标ID.id_变换, 0, editBoxMat);
//
//	f_vg_set实例数量(画布, m_光标ID.id_元素, 1);
//}
//
//void ui_绘制模板_块文本绘制::f_输入完成(S_2D画布* 画布, C_文本框* box) {
//	mat3X2 editBoxMat;
//
//	editBoxMat.row0 = box->g光标绘制位置;
//	editBoxMat.row1 = { 1, 20 };
//	editBoxMat.row2 = { 1, 0 };
//	f_vg_set变换(画布, m_光标ID.id_变换, 0, editBoxMat);
//
//	f_vg_set实例数量(画布, m_光标ID.id_元素, 1);
//}
//
//void ui_绘制模板_块文本绘制::f_框选(S_2D画布* 画布, C_文本框* box) {
//	return;
//	bool GPU参数重新配置 = f_ui绘制模板_重置凸矩形数量(画布, m_选取ID, box->m_文档->m_文本块.size());
//
//
//	int32 行数 = box->m_选取.结束行列.y - box->m_选取.开始行列.y;
//	int32 开始行 = box->m_选取.开始行列.y;
//
//
//
//	int32 起始列;
//	int32 结束列;
//	if (行数 < 0) {
//		行数 = abs(行数);
//		开始行 = box->m_选取.结束行列.y;
//		//结束列 = box->m_选取.开始行列.x;
//		//起始列 = box->m_选取.结束行列.x;
//	}
//	else {
//		//起始列 = box->m_选取.开始行列.x;
//		//结束列 = box->m_选取.结束行列.x;
//	}
//
//	//std::cout << "列 = " << box->m_选取.结束行列.x << " : " << box->m_选取.开始行列.x << std::endl;
//	if (!(box->m_选取.结束行列.x - box->m_选取.开始行列.x) && !行数) {
//		f_vg_set实例数量(画布, m_选取ID.id_元素, 0);
//		return;
//	}
//
//	f_vg_set实例数量(画布, m_选取ID.id_元素, 行数+1);
//	
//	
//	//float32 推进 = box->m_文本边偏移.x;
//	vec2 viewOffset = box->m_Pos;
//
//	
//	f_vg_set实例数量(画布, m_光标ID.id_元素, 0);
//}













ui_绘制模板_曲线::ui_绘制模板_曲线() {
	m_曲线点 = nullptr;
	m_曲线ID = nullptr;

	m_曲线点Ptr = nullptr;
	m_点元素 = 0;
	m_点数量 = 0;
}

void ui_绘制模板_曲线::f_Draw控制点(S_2D画布* 画布, uint16 属性ID) {
	m_画布 = 画布;
	if(!m_曲线点) m_曲线点 = f_vg_gen曲线(m_画布);
	//assert(m_曲线ID);
	m_点元素 = f_vg_画曲线点(m_画布, 属性ID, m_曲线点);
}

void ui_绘制模板_曲线::f_Draw(S_2D画布* 画布, uint16 属性ID, bool 多曲线) {
	m_画布 = 画布;

	if (!m_曲线点) m_曲线点 = f_vg_gen曲线(m_画布);
	m_线元素 = f_vg_画曲线(m_画布, 属性ID, m_曲线点, 1.2, 多曲线);
}


void ui_绘制模板_曲线::f_begin(uint32 线段区数量) {
	
	if (!线段区数量) {
		m_画布->m_surf[m_线元素].m_实例数量 = 0;
		return;
	}
	else {
		if (m_点元素) {
			m_画布->m_surf[m_点元素].m_实例数量 = 线段区数量;
		}
	}

	f_resize板载缓存_Up(m_曲线点, 线段区数量);
	m_画布->m_surf[m_线元素].m_实例数量 = 线段区数量 - 1;
	m_曲线点Ptr = f_vg_map曲线坐标(m_曲线点);
	
	m_点数量 = 线段区数量;
}

void ui_绘制模板_曲线::f_end() {
	if (m_曲线点Ptr) {
		m_曲线点->f_unmap();
	}
	m_曲线点Ptr = nullptr;
}

void ui_绘制模板_曲线::f_setPoint(uint32 offset, const S_CurvePoint2& 曲线点) {
	m_曲线点Ptr[offset] = 曲线点;
}

void ui_绘制模板_曲线::f_setPointColor(uint32 offset, const uint32 color) {
	m_曲线点Ptr[offset].ID_Color.y = color;
}

void ui_绘制模板_曲线::f_setPointColor(uint32 offset, const S_RGBA8UI& color) {
	m_曲线点Ptr[offset].ID_Color.y = f_PackData4X8(color);
}

void ui_绘制模板_曲线::f_setPointSelect(uint32 offset, uint32 b) {
	m_曲线点Ptr[offset].Select_Type.x = b;
}

void ui_绘制模板_曲线::f_setPointType(uint32 offset, uint32 b) {
	m_曲线点Ptr[offset].Select_Type.y = b;
}

void ui_绘制模板_曲线::f_setLine(uint32 offset, uint16 left_id, uint16 rigth_id) {
	
}

void ui_绘制模板_曲线::f_插入点(const S_CurvePoint2& 曲线点, const S_RGBA8UI& color, uint32 链接ID, uint64 offset) {
	uint32 c = f_PackData4X8(color);
	f_buf_insert(m_曲线点, offset, &曲线点, 1);
}

void ui_绘制模板_曲线::f_map() {
	m_曲线点Ptr = f_vg_map曲线坐标(m_曲线点);
}

void ui_绘制模板_曲线::f_unmap() {
	m_曲线点->f_unmap();
	m_曲线点Ptr = nullptr;
}













ui_绘制模板_自定义线::ui_绘制模板_自定义线() {
	m_画布 = nullptr;
	m_Prt = {};
	m_ID = {};
	m_NextID = 0;
}

ui_绘制模板_自定义线::~ui_绘制模板_自定义线() {
	if(m_ID.id_变换.m_Buf) f_bm_erase(m_ID.id_变换);
	if(m_ID.id_颜色.m_Buf) f_bm_erase(m_ID.id_颜色);

	m_ID.id_变换 = {};
	m_ID.id_颜色 = {};
}

void ui_绘制模板_自定义线::f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷) {
	m_画布 = 画布;
	
	switch (笔刷) {
	case e_圆公切链接线:
		break;
	default:
		break;
	}
	
	//f_vg_set绘制线(m_画布, m_ID.层ID, 1, {});

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = 0;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = 0;

	m_画布->m_surf[m_ID.层ID].m_实例偏移 = 0;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = 0;
}

void ui_绘制模板_自定义线::f_alloc(uint32 num, const S_RGBA8UI& C) {
	f_bm_resize(m_画布->m_surf[m_ID.层ID].m_顶点, num);

	f_bm_resize(m_ID.id_变换, 1);
	f_bm_resize(m_ID.id_颜色, 1);
	m_NextID = 0;

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = num;

	m_画布->m_surf[m_ID.层ID].m_实例偏移 = m_ID.id_变换.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_实例数量 = m_ID.id_变换.m_Mem.m_数量;

	f_buf_Mat3X2_at(m_ID.id_变换, 0) = {{},{1,1}, {}};
	f_buf_UI32_at(m_ID.id_颜色, 0) = f_PackData4X8(C);
}

void ui_绘制模板_自定义线::f_End() {
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_NextID;
}

void ui_绘制模板_自定义线::f_set下一个顶点(const vec2& pos, const S_RGBA8UI& C) {
	//return;
	f_vg_set绘制线(m_画布, m_ID.层ID, m_NextID, pos);
	++m_NextID;

	m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_NextID;

}

void ui_绘制模板_自定义线::f_set顶点(uint32 id, const vec2& pos) {
	if (m_画布) {
		f_vg_set绘制线(m_画布, m_ID.层ID, id, pos);

		m_画布->m_surf[m_ID.层ID].m_顶点偏移 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_偏移;
		m_画布->m_surf[m_ID.层ID].m_顶点数量 = m_画布->m_surf[m_ID.层ID].m_顶点.m_Mem.m_数量;
	}
}

void ui_绘制模板_自定义线::f_set顶点(uint32 id, const vec2& pos, const S_RGBA8UI& C) {
	f_vg_set绘制线(m_画布, m_ID.层ID, id, pos);

	f_buf_UI32_at(m_ID.id_颜色, id) = f_PackData4X8(C);
}

void ui_绘制模板_自定义线::f_Close(uint32 num) {
	//return;
	lines.clear();
	m_NextID = num;
	m_画布->m_surf[m_ID.层ID].m_顶点数量 = num;
}

void ui_绘制模板_自定义线::f_get线坐标() {
	//return;
	if (m_NextID) {
		lines.resize(m_NextID);

		S_2D图元顶点* points = f_buf_图元顶点_ptr(m_画布->m_surf[m_ID.层ID].m_顶点);

		for (uint32 i = 0; i < m_NextID; ++i) {
			lines[i] = points[i].coord;
		}
	}
}







//ui_绘制模板_表格::ui_绘制模板_表格() {
//	m_画布 = nullptr;
//	m_层 = 0;
//	m_大小 = {60,20};
//}
//
//ui_绘制模板_表格::~ui_绘制模板_表格() {
//	if(m_表格线.m_Buf) f_bm_erase(m_表格线);
//	if(m_颜色.m_Buf) f_bm_erase(m_颜色);
//}
//
//void ui_绘制模板_表格::f_Draw(S_2D画布 * 画布, uint16 属性ID) {
//	m_画布 = 画布;
//
//	m_表格线 = f_bm_alloc(m_画布->g表格变换GPU缓存, 1);
//	m_颜色 = f_bm_alloc(m_画布->g表格颜色GPU缓存, 1);
//
//	m_层 = f_vg_画表格(画布, 画布->m_属性[属性ID]);
//
//}
//
//void ui_绘制模板_表格::f_fill(uint32 hNum, uint32 vNum) {
//	uint32 num = DEF_Max(hNum, 1) * DEF_Max(vNum, 1);
//	f_bm_resize(m_表格线, num);
//	f_bm_resize(m_颜色, num);
//	
//	m_画布->m_surf[m_层].m_实例偏移 = m_表格线.m_Mem.m_偏移;
//	m_画布->m_surf[m_层].m_实例数量 = m_表格线.m_Mem.m_数量;
//
//	vec2* 线指针 = f_buf_Vec2_ptr(m_表格线);
//	uint32* 颜色指针 = f_buf_UI32_ptr(m_颜色);
//	for (uint32 y = 0; y < vNum; ++y) {
//		for (uint32 x = 0; x < hNum; ++x) {
//			uint32 index = y*hNum + x;
//			线指针[index] = { m_大小.x * x, m_大小.y * y };
//			颜色指针[index] = f_PackData4X8({50,50,50,255});
//		}
//	}
//}
//
//void ui_绘制模板_表格::f_Close(uint32 num) {
//	m_画布->m_surf[m_层].m_实例数量 = num;
//}



ui_绘制模板_纹理::ui_绘制模板_纹理() {
	m_画布 = nullptr;
	m_纹理变换 = {};
	m_纹理属性 = {};

	m_纹理ID = {};
}

ui_绘制模板_纹理::~ui_绘制模板_纹理() {
	f_bm_erase(m_纹理变换);
	f_bm_erase(m_纹理属性);
}

void ui_绘制模板_纹理::f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷, S_纹理* 纹理) {
	m_画布 = 画布;
	
	m_纹理变换 = f_bm_alloc(S_2D画布::g纹理变换, 1);
	m_纹理属性 = f_bm_alloc(f_buf_getGlobal().g_纹理属性, 1);
	m_纹理ID = f_bm_alloc(f_buf_getGlobal().m_UI32动态属性, 1);

	switch (笔刷) {
		case e_单色纹理:
			break;
		case e_纹理:
			m_层ID = f_vg_画纹理(m_画布, 属性ID, 纹理);
			break;
		case e_条纹:
			break;
		case e_色轮:
			break;
		case e_渐变:
			break;
		case e_噪波:
			m_层ID = f_vg_画噪波(m_画布, 属性ID);
			break;
		default:
			break;
	}
	
	auto& 层 = m_画布->m_surf[m_层ID];
	层.m_间接 = f_bm_alloc(f_buf_getGlobal().g间接, 1);
	层.m_实例数量 = 1;
	层.m_顶点数量 = 0;
	层.m_顶点偏移 = 0;
}

void ui_绘制模板_纹理::f_Draw(S_2D画布* 画布, uint16 属性ID, S_纹理集* 纹理集) {
	m_画布 = 画布;

	m_纹理变换 = f_bm_alloc(S_2D画布::g纹理变换, 1);
	m_纹理属性 = f_bm_alloc(f_buf_getGlobal().g_纹理属性, 1);
	m_纹理ID = f_bm_alloc(f_buf_getGlobal().m_UI32动态属性, 1);

	m_层ID = f_vg_画多纹理(m_画布, 属性ID, 纹理集, &m_ConstPush);

	auto& 层 = m_画布->m_surf[m_层ID];
	层.m_间接 = f_bm_alloc(f_buf_getGlobal().g间接, 1);
	层.m_实例数量 = 1;
	层.m_顶点数量 = 0;
	层.m_顶点偏移 = 0;
}

void ui_绘制模板_纹理::f_alloc(uint32 num) {
	auto& 层 = m_画布->m_surf[m_层ID];

	f_bm_resize(m_纹理变换, num);
	//f_gbuf_resize(m_纹理属性, num);
	f_bm_resize(层.m_间接, num);
	f_bm_resize(m_纹理ID, num);

	层.m_实例数量 = m_纹理变换.m_Mem.m_数量;
	层.m_实例偏移 = m_纹理变换.m_Mem.m_偏移;

	m_ConstPush.MO_Tranform = m_纹理变换.m_Mem.m_偏移;
	m_ConstPush.MO_TextureID = m_纹理ID.m_Mem.m_偏移;
}

uint32 ui_绘制模板_纹理::f_set(uint32 id, const mat3X2& mat, const uvec2& 图元ID, const S_RGBA8UI& C, const S_TextueProp& texProp) {
	auto& 层 = m_画布->m_surf[m_层ID];

	f_buf_Mat3X2_at(m_纹理变换, id) = mat;
	f_buf_Indirect_at(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_纹理变换.m_Mem.m_偏移) };

	f_buf_纹理属性_at(m_纹理属性, id) = texProp;

	return m_纹理属性.m_Mem.m_偏移;
}

uint32 ui_绘制模板_纹理::f_set(uint32 id, const mat3X2& mat, const uvec2& 图元ID, uint32 texID) {
	auto& 层 = m_画布->m_surf[m_层ID];

	f_buf_Mat3X2_at(m_纹理变换, id) = mat;
	f_buf_Indirect_at(层.m_间接, id) = { 图元ID.y - 图元ID.x, 1, 图元ID.x, uint32(id + m_纹理变换.m_Mem.m_偏移) };
	f_buf_UI32_at(m_纹理ID, id) = texID;

	return m_纹理属性.m_Mem.m_偏移;
}


void ui_绘制模板_纹理::f_绑定纹理(S_纹理* text, uint32 id, const S_RGBA8UI& C) {
	auto& 层 = m_画布->m_surf[m_层ID];

	层.m_笔刷.m_纹理信息[id] = text;
	层.m_笔刷.m_纹理参数数量 = 1;
}

void ui_绘制模板_纹理::f_Close(uint32 num) {
	m_画布->m_surf[m_层ID].m_实例数量 = num;
}





ui_绘制模板_线段::ui_绘制模板_线段() {
	m_画布 = nullptr;
	m_线段数据 = {};
	m_层ID = 0;
}

ui_绘制模板_线段::~ui_绘制模板_线段() {
}

void ui_绘制模板_线段::f_Draw(S_2D画布* 画布, uint16 属性ID, E_笔刷类型 笔刷) {
	m_画布 = 画布;
	switch (笔刷) {
	case E_笔刷类型::e_圆公切链接线:
		m_层ID = f_vg_画园公切线链接线(m_画布, 属性ID, 1.0);

		m_线段数据 = f_bm_alloc(S_2D画布::g线段, 0);
		return;
	}
}

void ui_绘制模板_线段::f_alloc(uint32 num) {
	f_bm_resize(m_线段数据, num);

	auto& 层 = m_画布->m_surf[m_层ID];

	层.m_顶点数量 = 1;
	层.m_顶点偏移 = 0;

	层.m_实例数量 = num;
	层.m_实例偏移 = m_线段数据.m_Mem.m_偏移;
}

void ui_绘制模板_线段::f_set(uint32 id, const S_CurvePoint2& point) {
	f_buf_曲线段_at(m_线段数据, id) = point;
}

void ui_绘制模板_线段::f_Close(uint32 num) {
	auto& 层 = m_画布->m_surf[m_层ID];
	层.m_实例数量 = 0;
}







